Este curso introductorio cubre los aspectos básicos del lenguaje que necesitas para iniciar en el área de Data Science con Python.Este curso esta dedicado principalmente para aquellos que ya tienen alguna experiencia con código o incluso otro lenguaje como R,Julia,Matlab,entre otros.
Primero comenzaremos con la sintáxis de Python,asi como la asignación de variables y operaciones aritméticas.
Generalmente en un proyecto de data science,necesitamos exponer resultados de modelos,graficos y/o analisis.De esta forma un primer mensaje que podria desarrollar,seria que nuestro proyecto fue exitoso,para esto debemos definir la variable en donde guardaremos el mensaje "El proyecto fue exitoso".
mensaje="El proyecto fue éxitoso"
print(mensaje)
El proyecto fue éxitoso
Como pueden ver exponer resultados en python,no es tan dificil como podriamos pensar.
Asi como en bloque de codigo anterior,en Python se puede trabajar con distintos tipos de variables:Númericas,String,entre otros subtipos.Pero cabe destacar que cuando hablamos de variables numericas,con ellas podemos realizar todo tipo de operaciones aritmeticas y con las variables de tipo String podemos generar textos que muestren la salida de un proceso exitoso o incluso generar documentación.
A continuación podemos ver un ejemplo de una variable numerica que almacena el valor 25 y un variable de tipo string que guarda el texto "Esta es mi edad"
numero=25
frase="Esta es mi edad"
Sin embargo podriamos trabajar con ambas variables en conjunto y mostrarlo como una salida,como se muestra continuación con la variable print()
print(frase,numero)
Esta es mi edad 25
Ya hemos visto dos tipos de variables,sin embargo si tenemos dudas acerca de la definción podemos verificar esto.
type(numero)
int
type(frase)
str
Como podemos ver en la salida del bloque,la variable que almacena el valor numero es de tipo "int",esto es una abreviación para "integer" o "entero",en cambio para la variable frase el tipo es "str" haciendo referencia a "string" o cadena de texto. Sin embargo,tambien podriamos definir una variable que almacene un valor numerico como texto,en este caso no podriamos realizar operaciones aritmeticas con el
otro_numero="30.2"
type(otro_numero)
print("La variable otro_numero,almacena el valor",otro_numero)
La variable otro_numero,almacena el valor 30.2
Sin embargo si quisieramos trabajar con variables numéricas con valores decimales como "30.2" "23.4" u otros podemos definir variable de tipo float.
numero_decimal=30.2
print("La variable numero_decimal,tiene el valor ",numero_decimal,
"y es de tipo",type(numero_decimal))
La variable numero_decimal,tiene el valor 30.2 y es de tipo <class 'float'>
De esta forma si quisieramos realizar operaciones matematicas con variables de tipo entero o float,se debe ocupar la siguiente sintaxis.
| Sintaxis | Operación | Descripción | | -- | -- | -- | | x + y | Adición | La suma de x e y | | x - y | Sustracción | La diferencia entre x e y | | x * y | Multiplicación | El producto entre x e y | | x / y | División | El cuociente entre x e y. | | x % y | Modulo | El valor entero restante,luego de dividir x entre y. | | x ** y | Potenciación | El resultado de elevar x a y. | | -x | Negación | El valor negativo de x. |
De acuerdo a lo anterior,podriamos realizar algunas operaciones básicas como suma,resta,división y multiplicación...definiendo previamente las variables x e y.
x=10
y=2
print(x+2)
12
print(x-2)
8
print(x/2)
5.0
print(x*y)
20
Pero tambien podriamos realizar algunos cálculos un poco mas complejo,como determinar volumenes de cubo,conos,u otras figuras.
lado=5
print("Un cubo tiene un volumen de:",lado**3,"cm^3")
Un cubo tiene un volumen de: 125 cm^3
alto=2
ancho=4
largo=7
print("El volumen de un paralelelipide es de: ",alto*ancho*largo,"cm^3")
El volumen de un paralelelipide es de: 56 cm^3
Asi como en la sección anterior vimos como definir,manipular algunos tipos de variables e incluso definir algunas formulas,en otros casos necesitaremos definir procedimientos más complejos y/o que requieren de varios pasos para su ejecución y para esto utilizaremos la definición de funciones,las cuales las podemos utilizar cada ves deseemos.
Podriamos definir una función simple que imprima por pantalla algunos valores
def mi_funcion1(nombre):
"Esta es la ayuda de la funcion"
saldo=100
return print("Buen dia: ",nombre,"su saldo en cuenta es de:",saldo)
mi_funcion1(nombre="juan")
Buen dia: juan su saldo en cuenta es de: 100
Toda funcion en Python,parte con la palabra reservada def,luego el nombre que en este caso es mi_funcion1 y dentro de parentesis las variables que acepta la funcion.Una vez que la variable acepta la variable nombre,se genera un saldo de 100 y se guarda en la variable saldo,finalmente la funcion retorna un mensaje para el usuario.
Sin embargo, si queremos saber un poco mas acerca de la función podemos llamar a la ayuda de esta con la funcion help()
help(mi_funcion1)
Help on function mi_funcion1 in module __main__:
mi_funcion1(nombre)
Esta es la ayuda de la funcion
En este caso no se entrega información,por que dentro de la función no existe.Sin embargo,podemos crear la descripción de la función utilizando dentro de ella la triple comillas """
def mi_funcion1(nombre):
"""Esta es la ayuda de la funcion.Esta función genera un
mensaje de salida con el nombre que se le entrega y el saldo que
por defecto se encuentra en 100"""
saldo=100
return print("Buen dia: ",nombre,"su saldo en cuenta es de:",saldo)
help(mi_funcion1)
Help on function mi_funcion1 in module __main__:
mi_funcion1(nombre)
Esta es la ayuda de la funcion.Esta función genera un
mensaje de salida con el nombre que se le entrega y el saldo que
por defecto se encuentra en 100
A diferencia del códgio anterior, ahora si se muestra de forma explícita que es lo que hace la función, lo cual se agrego en la nueva definición de la función "mi_función1".
Pero tambien podemos definir funciones que realicen algunas operaciones mas extensas,asi como operaciones matematicas que tomen distintos valores segun las variables que se le definan a la función.
En este caso la funcion diferencia,determina las diferencias absolutas que existen entre 3 variables a,b y c.Asi, las diferencias se determinan al interior de la función y luego se retornan junto al texto que muestra entre que pares de variables se determinan las diferencias,cabe destacar que para esta función tambien se escribio la ayuda.
def diferencia(a,b,c):
""" Esta funcion retorna la diferencia entre 3 valores que se le entregan"""
dif1=abs(a-b)
dif2=abs(a-c)
dif3=abs(b-c)
return print("La diferencia entre a y b es",dif1,"La diferencia entre a y c es",dif2,"y la diferencia entre b y c es",dif3)
help(diferencia)
diferencia(10,20,30)
Help on function diferencia in module __main__:
diferencia(a, b, c)
Esta funcion retorna la diferencia entre 3 valores que se le entregan
La diferencia entre a y b es 10 La diferencia entre a y c es 20 y la diferencia entre b y c es 10
Pero aún podemos complicar las funciones un poco mas...En muchos casos utilizaremos funciones para tareas especificas,pero en otros podriamos necesitar aplicar a una función otra función de forma inmediata,de esa forma a la salida de la primera se le aplicara una nueva función.Si creamos una primera función multi_1(x), la que multiplica por 2 el valor de entrada podriamos modificar la salida con una nueva función multi_2(fn)
def multi_1(x=2):
"""Esta primera función solo multiplica por 2 la variable de entrada,por defecto el valor de entrada esta fijado en 2"""
y=x*2
return y
def multi_2(fn):
""" Esta funcion toma la salida de otra funcion y la multiplica por 2"""
z=fn*3
return z
multi_2(multi_1(10))
60
Asi podemos llamar a una función dentro de otra,en este caso al dar el valor de entrada como 10 a la función multi_1(),esta lo multiplica por 10 y devuelve un 20.Asi luego este valor 20 lo toma la función multi_2() y lo multiplica por 3,obteniendo asi el valor 60 que se muestra por pantalla.
Ya vimos que en python existen distintos tipos de variables como "integer" y "string",pero no siempre trabajaremos con números o texto.Podemos utilizar las variables "bool",las cuales tienen 2 posibles valores "True" o "False".
Estas variables las podemos obtener como salida de otras funciones,pero tambien podemos definir y validar este tipo de variable cada vez que sea necesario.
x=True
print(x)
print(type(x))
True <class 'bool'>
En este caso podemos ver que el valor de x,es "Verdadero" y al validar el tipo de variables que es x,nos devuelve por pantalla que es "bool" o "booleano".
Tambien podemos definir otras variables y verificar si sus valores son iguales o distintos.
y=False
x==y
False
En este caso al definir una nueva variable y como "False",podemos observar que al verificar con el signo "==" si son iguales,se nos devuelve el valor "False",debido a que x tiene asignado el valor Verdadero en cambio y tiene asignado el valor Falso.
Sin embargo podemos utilizar varios operadores entre variables booleanas según corresponda.
| Operación | Descripción | | -- | -- | |x == y|x es igual y|| |x < y|x es menor y| | |x <= y|x es menor o igual que y|| |x != y|x no es igual a y|| |x > y|x es mayor que y|| |x >= y|x es mayor o igual que y||
Asi podemos integrar este tipo de variables y las operaciones ya definidas en alguna función que realice algun otro procedimiento mas extenso.
def cajero(tarjeta):
""" La función permite validar si el tarjeta tiene saldo o no """
saldo=100
if tarjeta==True:
return print("Su saldo es de",saldo)
else:
return print("No se puede verificar su saldo en este momento")
cajero(tarjeta=True)
Su saldo es de 100
Asi se puede verificar que si la variable tarjeta tiene el valor verdadero en el cajero,la función cajero devuelve el mensaje "Su saldo es de 100" y en caso contrario no puede validar el saldo.
Como vimos en el código anterior podemos verificar el valor asignado a una variable numérica,booleana o string,mediante un operador y una condición. Esto debido a que si una variable cumple cierta condición,se ejecuta un bloque de código,sino se ejecuta otro bloque de código.
Aunque también podemos verificar si se cumple mas de una condición, como en la siguiente función inspector.
def inspector(x):
if x==0:
print(x,"Es cero")
elif x>0:
print(x,"Es positivo")
else:
print(x,"Es negativo")
inspector(0)
inspector(-10)
0 Es cero -10 Es negativo
En este caso la función una vez que se le entrega un valor numérico,es capaz de determinar si es igual a 0,mayor a 0 o incluso si es menor que 0.
Esto se realiza mediante la condición if,en donde esta condición if verifica que se cumpla la condición x==0,sino se cumple se utiliza la verificación de que sea mayor a 0 con elif y si no se cumple ninguna de las 2 anteriores se ejecuta el ultimo bloque de código correspondiente al print(x,"Es negativo").
Algunas ultimas consideraciones para las variables booleanas.Podemos convertir casi cualquier tipo de dato a una variable booleana,de esta forma todo valor positivo o texto no vacio sera considerado en Python como un valor Verdadero y el valor 0 o texto vacío como Falso,como en el siguiente caso.
print(bool(12))
print(bool("hola"))
print(bool(0))
print(bool(""))
True True False False
Las listas en python son una estructura de datos similar a lo que hacemos con las variables que ya conocemos,pero nos permiten realizar operaciones mas complejas.
De esta forma en una lista podemos almacenar una secuencia de valores, como las listas generadas para las variables primos y días a continuación.
primos=[2,3,5,7]
dias=["Lunes","Martes","Miercoles","Jueves","Viernes"]
Como se puede ver ambas son listas, sin embargo en la primera almacenamos solo valores númericos y en la segunda se guardan string.
Pero lo podemos llevar un poco más allá y crear una lista de listas 👀
cartas=[["j","q","k"],[2,3,5],[5,"A","K"]]
En este caso generamos una lista compuesta por 3 listas,sin embargo cada una de estas listas es diferente.La primera solo contiene valores string,la segunda solo valores numericos y la tercera contiene tanto valores numericos como string.
Ya que tenemos una lista que tiene una estructura mas extensa,podriamos querer seleccionar alguno de sus valores y no siempre tratar con la lista cartas completa.Asi podriamos seleccionar
print(cartas[1])
print(cartas[2])
[2, 3, 5] [5, 'A', 'K']
Asi podemos seleccionar la segunda lista de cartas o incluso seleccionar la tercera lista de cartas.Pero incluso podriamos seleccionar uno de los elementos de estas listas como en el siguiente bloque.
print(cartas[1][0])
print(cartas[2][2])
2 K
Ahi se puede ver como podemos seleccionar el primer elemento de la segunda lista obteniendo el valor de 2 o seleccionar el tercer elemento de la tercera lista obteniendo el string K.
Pero si una vez que definimos la lista carta,queremos agregar una nueva mano...perdon una nueva lista,podemos hacerlo con la siguiente asignación.
cartas[0]=["A","J","Q"]
cartas
[['A', 'J', 'Q'], [2, 3, 5], [5, 'A', 'K']]
Ahora como era de esperar,también podemos utilizar algunas funciones sobre estas listas.En este caso podriamos querer determinar la cantidad de días que tiene la variable días 😅...o incluso ordenar los días de forma alfabetica ...o incluso operaciones matemáticas como la suma de los números primos o determinar el maximo de ellos.
# Cuantos dias hay en una semana
print(len(dias))
# Ordenar los dias de forma alfabetica
print(sorted(dias))
# suma de los numeros primos
print(sum(primos))
# maximo de los numeros primos
print(max(primos))
5 ['Jueves', 'Lunes', 'Martes', 'Miercoles', 'Viernes'] 17 7
A diferencia de las funciones que ya vienen creadas en python o las que podemos definir nosotros.También existen métodos que vienen ya creados en python Built-in,los que sin embargo dependen del tipo de variable con la que estemos trabajando
Algunas de los métodos que ya vienven construidos en Python para distintos tipos de variables: |Método|Descripción| |--|--| |capitalize()|Convierte en mayuscula la primera letra del string.| |index()|Busca la posición de un caracter y la devuelve.| |split()|Divide un string,según el separador que se indique y lo convierte en lista.| |upper()|Convierte todas las letras de un string en mayusculas.| |lower()|Convierte todas las letras de un string en minusculas.|
texto="este es un texto de prueba"
texto.capitalize()
'Este es un texto de prueba'
texto.index("texto")
11
texto.split()
['este', 'es', 'un', 'texto', 'de', 'prueba']
texto.upper()
'ESTE ES UN TEXTO DE PRUEBA'
texto.lower()
'este es un texto de prueba'
Pero tambien podriamos utilizar métodos sobre variables numericas,listas y otros.Sin embargo la diferencia principal entre un método y una función es que los métodos siempre seran parte de una clase,de otra forma son parte de las funcionalidades que le podemos dar a un objeto.
Tal vez hasta el momento no hemos hablando de objetos,sin embargo los objetos son una de las caracteristicas principales de Python,ya que este es un software que soporta la Programación Orientada a Objetos (POO),de los cuales hablaremos mas adelante.
Las tuplas son similares a las listas,sin embargo tienen algunas diferencias con las listas.En un principio las podemos definir de forma similar la generada y guardada en la variable t
t=(1,2,3)
t
(1, 2, 3)
En este caso solo cambiamos el tipo de parentesis para crear la tupla t,sin embargo si quisieramos cambiar alguno de los valores de la tupla como en los casos anteriores no podemos,a continuación se muestra un error forzado...👀
t[0]=1
--------------------------------------------------------------------------- TypeError Traceback (most recent call last) Input In [37], in <cell line: 1>() ----> 1 t[0]=1 TypeError: 'tuple' object does not support item assignment
Pero como ya vimos,tambien podemos utilizar métodos sobre tuplas.En este caso si tenemos una variable tipo float,podemos utilizar el método as_integer_ratio() para devolver una tupla compuesta por el numerador y denominador de la variable float.
x=0.125
numerador,denominador=x.as_integer_ratio()
print(numerador/denominador)
dias=["Lunes","Martes","Miercoles","Jueves","Viernes","Sabado"]
Y podriamos ir mostrando por pantalla cada uno de los días con un ciclo for
for i in dias:
print(i)
Lunes Martes Miercoles Jueves Viernes
Como se puede ver el ciclo for itera la variable i sobre la lista dias,asi va tomando cada uno de los valores e imprime el dia por pantalla.
En cambio si tomaramos una lista numerica y la iteramos de igual forma,solo imprimiria los valores numericos de esta lista.
numeros=[1,2,3,4,5]
for j in numeros:
print(j)
1 2 3 4 5
Asi podemos ver que en este caso cambiamos la lista para luego iterar con una nueva variable,en este caso j.
Ademas no solo podemos iterar los valores en una lista, tambien podriamos realizar alguna operación dentro del ciclomen este caso definimos una nueva lista y luega la variable producto.
multiplicativos=(2,2,2,3,3,5)
producto=1
for i in multiplicativos:
producto=producto*i
producto
360
En este caso el ciclo for itera los valores de lista multiplicativos y luego en cada iteración multiplica el valor de la variable producto por el valor de multiplicativos y lo almacena.
for i in range(5):
print("Este i es el numero: ",i)
Este i es el numero: 0 Este i es el numero: 1 Este i es el numero: 2 Este i es el numero: 3 Este i es el numero: 4
Retomando el primer ciclo,tambien podriamos utilizar la función range(), para optimizar la iteración de la variable i.Asi no es necesario definir la lista a iterar y solo asignamos el valor hasta el que deseamos iterar a la funcion range().
Además del ciclo for que vimos en la sección anterior,tambien podemos querer iterar una lista o un proceso mientras se cumpla una cierta condición.Para esto utilizamos el ciclo while,que a diferencia del caso anterior en donde iteramos una variable,para el ciclo while esperamos que mientras se cumpla una condición se ejecutaran las intrucciones que estan dentro de el.
Cabe destacar que para el ciclo while hay que tener una consideración especial,ya que si la condición que establecemos no se cumple nunca el ciclo while se ejecuta de forma infinita pudiendo ocasionar que el software o el pc consuma toda la memoria y teniendo que reinciar el proceso o incluso el pc.
A continuación se define el valor de la variable i=0,entonces el ciclo comienza validando esta condición,como es verdadera luego imprime el valor de la variable y luego i=i+1.Finalmente esta operación se repite hasta que i toma el valor 9,ya que al tomar el valor 10,la condición i<10 ya no es verdadera.
i=0
while i<10:
print(i,end=" ")
i=i+1
0 1 2 3 4 5 6 7 8 9
En cambio si ejecutamos el siguiente bloque el ciclo se ejecuta de forma infinita ya que la condición siempre sera cierta,provocando que el software colapse y se cierre... 🔥
i=True
while i==True:
print(i)
Otro aspecto importante en Python,es que cuando definimos una lista es posible utilizar ciclos dentro de ellas.En algunos casos solo requerimos de algunos valores dentro de una lista,pero si buscamos crear una sucesión que tenga una mayor extensión,como tal vez una lista con los valores del 1 al 20 una forma sencilla de escribirla seria de la siguiente forma:
serie_1=[n for n in range(1,21)]
serie_1
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
Recordar que en Python el limite superior esta especificado por el valor siguiente,es por eso que dentro de la función range() utilizamos 21 y no 20.
Pero no siempre necesitaremos crear las mismas listas en algunos casos podriamos necesitar que la lista comience o termine en valores distintos.Paro lo cual podriamos hacer uso de las funciones...las cuales son nuestro mejor aliado cuando queremos encapsular un proceso que realizamos con mucha frecuencia 📲
def listas(inicio=1,termino=5):
return [n for n in range(inicio,termino)]
l1=listas()
l1
[1, 2, 3, 4]
l2=listas(inicio=10,termino=21)
l2
[10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
Como se en el primer bloque,una vez que definimos la función listas y la llamamos para crear nuestra primera lista l1,se crea la lista con los valores por defecto.Sin embargo cuando la llamamos para crear la lista l2 con diferentes limites,inmediatamente se crea la lista con los valores que comienzan en el 10 y terminan en el 20.📌
Hasta este punto del curso,ya hemos visto la mayoria de los aspectos importantes para comenzar al menos a trabajar con Python,sin embargo uno de los puntos en donde Python es excelente es con la manipulación de strings o cadenas de texto.
Si bien ya hemos definido y realizado algunas operaciones con strings,siempre es bueno repasar antes de pasar a lo mas interesante de esta sección...los diccionarios. 📚
Habiamos visto que se podian definir algunas cadenas de texto y almacenarlas en variables como las que se muestran a continuación
x="lunes es un dia"
y="Lunes es un dia"
False
Como podemos ver aca, en ambas variables se guardo exactamente la misma cadena texto.Por lo tanto si posteriormente qusieramos validar estos valores podriamos hacer lo siguiente
x==y
Entonces como podemos ver,si validamos si lo que se encuentra en la variable x es igual a lo que esta en y nos devuelve un False,lo cual ocurre por que el texto es el mismo,pero la primera letra de lo guardado en X se encuentra en minuscula.
En cambio si definimos las cadenas de texto exactamente de la misma forma.
x="Lunes es un dia"
y="Lunes es un dia"
x==y
True
Ahora si verificamos que ambas cadenas de texto son iguales.
En cambio tambien podriamos querer en algunos saltar una linea,como en lo siguiente.
a=print("Lunes\nes un dia")
a
Lunes es un dia
En este caso vemos que al agregar el "\n",inmediatamente todo lo que viene despues se escribe en la linea siguiente...Y por supuesto podriamos volver a utilizarlo si quisieramos escribir cada palabra en una linea nueva
a=print("Lunes\nes\nun\ndia")
a
Lunes es un dia
Como ya hemos trabajado con la funcion,sabemos que esta automaticamente agrega una nueva linea,a menos que especifiquemos un valor de termino.
print("Martes es otro dia de la semana")
print("Miercoles es otro dia de la semana",end='')
print("Jueves es otro dia de la semana",end='')
Martes es otro dia de la semana Miercoles es otro dia de la semanaJueves es otro dia de la semana
Como se puede ver en el caso anterior si utilizamos el print de toda la vida,el siguiente texto que se imprime se va a la siguiente linea.Sin embargo cuando hacemos la segunda impresión agregamos el argumento end= '',el cual en este caso permite que una vez impreso el texto se siga en la misma linea,a menos que usemos el valor \n que viene por defecto.
print("Viernes es otro dia de la semana",end='\n')
print("El sabado no se trabaja")
Viernes es otro dia de la semana El sabado no se trabaja
Pero las cadenas de texto,no solo pueden ser un conjunto de palabras,sino que podemos separar estas en caracteres.
Si consideramos la ultima cadena de texto:
sabado="El sabado no se trabaja"
sabado[3]
's'
Como podemos ver,es posible almacenar una cadena de texto en una variable para luego ir seleccionado cada uno de los caracteres en ella,e ir poco a poco concatenando los caracteres de toda la cadena de texto.
sabado="El sabado no se trabaja"
sabado[0]+sabado[1]+sabado[2]+sabado[3:9]
'El sabado'
E incluso podriamos determinar la cantidad de letras que tiene la frase "El sabado no se trabaja"
len(sabado)
23
Hasta el momento hemos trabajado con characteres,cadenas de texto o strings y variables numericas.Pero uno de los aspectos mas importantes en Python son los diccionarios,los cuales son estructuras de datos que permiten mapear claves a valores,esto implica que podemos indexar un conjunto de valores a otro conjunto de claves.
numeros={"uno":1,"dos":2,"tres":3}
numeros
numeros["tres"]
3
En el caso del diccionario numeros,"uno","dos" y "tres" son las llaves y los valores 1,2 y 3 son los valores.
En este caso podemos acceder a cada uno de los valores mediante las llaves.
numeros["uno"]
1
Asi podemos seleccionar el primer valor,pero tambien podriamos agregar otros valores mediante una nueva llave.
numeros["cuatro"]=4
numeros
{'uno': 1, 'dos': 2, 'tres': 3, 'cuatro': 4}
O incluso cambiando solo alguno de aquellos valores ya asociados a una llave.
numeros["uno"]="Lunes"
numeros
{'uno': 'Lunes', 'dos': 2, 'tres': 3, 'cuatro': 4}
Asi finalmente podriamos incluso iterar un diccionario mediante un ciclo for.
for i in numeros:
print(numeros[i])
Lunes 2 3 4
O incluso validar si una llave se encuentra en el diccionario.
"uno" in numeros
True
"cinco" in numeros
False
numeros
{'uno': 1, 'dos': 2, 'tres': 3}
Algunos otras operaciones que podemos hacer en Python,es renombrar los valores de un diccionario mediante una iteración de los valores de las llaves del mismo diccionario.
dias=["lunes","martes","miercoles","jueves","viernes"]
dias_json={dia:dia[0] for dia in dias}
dias_json
{'lunes': 'l', 'martes': 'm', 'miercoles': 'm', 'jueves': 'j', 'viernes': 'v'}
En este caso, se creo un diccionario en donde sus llaves son los dias de la semana y los valores corresponden a a cada uno de los primeros caracteres de las llaves.
Pero incluso el valor podria ser una versión mas corta del nombre de la llave o una pequeña descripción si fuera el caso.En este caso al cambiar la cantidad de caracteres a seleccionar de dia[0] a dia[0:3], se pasa de solo considerar la primera letra a las 3 primeras.
dias=["lunes","martes","miercoles","jueves","viernes"]
dias_json={dia:dia[0:3] for dia in dias}
dias_json
{'lunes': 'lun',
'martes': 'mar',
'miercoles': 'mie',
'jueves': 'jue',
'viernes': 'vie'}
Finalmente, si quisieramos podriamos utilizar métodos sobre los diccionarios que hemos creado para realizar algunas tareas sencillas.
dias_json.values()
dict_values(['lun', 'mar', 'mie', 'jue', 'vie'])
En este caso se utilizo el método .values() para mostrar por pantalla todos los valores del diccionario.
Y llegamos al último tópico de este curso introductorio 🎉
Hay varios temas que hemos tocado en este curso desde la declaración de variables numéricas,string y booleanas e incluso algunas estructuras de datos.Pero aún queda ver como podemos trabajar con librerías dentro del entorno de Python las cuales son muy importantes si queremos extender las capacidades de Python,si bien no veremos todas las librerías que se pueden utilizar en Python ya que son muchas,las cuales van desde la definición de variables numéricas,desarrollo de gráficas,conexión a bases de datos,desarrollo de interfaces de usuario e incluso el uso de modelos de machine learning y darian para material de un curso mas avanzado.Sin embargo, veremos 3 librerías ampliamente usadas tanto en la industria como en la academia.
La primera es Numpy la que es una librería especializada en cálculo numérico y el análisis de datos,uno de los aspectos mas importante es que se puede definir una estructura de dato llamada arrays los cuales se procesan mucho mas rápido que las listas que por defecto maneja Python 🙄.La segunda es Matplotlib que es una librería estándar para comenzar a desarrollar visualizaciones en Python y la tercera es Plotly otra librería de visualización,la que personalmente me gusta por su sintáxis, simplicidad y por que además tambien se encuentra implementada para el Software R.
Como ya habiamos dicho uno de los puntos fuertes de la librería Numpy son los objetos array,que se componen de elementos del mismo tipo y que pueden ser de 1,2 o n dimensiones.Asi podriamos definir una lista o array de 1 dimensión,una matriz o array de 2 dimensiones o tambien un cubo que seria un array de 3 dimensiones.
Sin embargo primero deberiamos cargar la libreria numpy
import numpy
Una vez cargada ya podremos utilizar todas las funciones que vienen dentro de esta libreria.Cabe destacar que podremos cargar la libreria con su nombre por defecto o con una forma abreviada,lo cual nos servira cada vez que llamemos a las funciones dentro de ella.
import numpy as np
A diferencia de las listas que podemos definir de forma regular en Python,para definir una lista o array de 1 dimension tenemos que
a1=np.array([10,20,30,40])
print(a1)
[10 20 30 40]
De la misma forma,si quisieramos definir un array de 2 dimensiones
a2=np.array([[10,20,30,40],[50,60,70,80]])
print(a2)
[[10 20 30 40] [50 60 70 80]]
Y siguiendo con la idea,entonces un array de 3 dimensiones lo podemos definir como sigue
a3=np.array([[[10,20,30],[40,50,60]],[[70,80,90],[110,120,130]]])
print(a3)
[[[ 10 20 30] [ 40 50 60]] [[ 70 80 90] [110 120 130]]]
Por tanto si quisieramos acceder a los elementos de cualquier tipo de array,debemos usar los índices al igual que accedemos a los elementos de una lista,pero seleccionando los índices de cada dimensión.
#Para acceder al elemento de la fila 0 columna 0 del array de 2 dimensiones
print(a2[0,0])
#Para acceder al elemento de la fila 1 columna 2 del array de 2 dimensiones
print(a2[1,2])
10 70
Pero tambien podriamos utilizar algunos métodos para obtener algunas caracteristicas importantes de un array,como las que se muestran en la siguiente tabla. |Atributo|Método|Detalle| |--|--|--| |N° de Dimensión|a.ndim()|Devuelve el número de dimensiones del array a.| |Dimensiones|a.shape()|Devuelve una tupla con las dimensiones del array a.| |Tamaño|a.size()|Devuelve el número de elementos del array a.| |Tipo de dato|a.dtype()|Devuelve el tipo de datos de los elementos del array a.|
# Número de dimensiones para cada uno de los arrays
print(np.ndim(a1))
print(np.ndim(a2))
print(np.ndim(a3))
1 2 3
# Dimensiones para cada uno de los arrays
print(np.shape(a1))
print(np.shape(a2))
print(np.shape(a3))
(4,) (2, 4) (2, 2, 3)
Como se puede ver en el primer caso con el método a.ndim(), solo se nos muestra la cantidad de dimensiones,pero con el método a.shape() se muestran las dimensiones explicitas.
Pero incluso podemos realizar operaciones con arrays,incluso si tienen distintas dimensiones y numero de dimensiones,ya que operaran solo sobre aquellas dimensiones disponibles.
print(a1*2)
[20 40 60 80]
print(2*a2/a2)
[[2. 2. 2. 2.] [2. 2. 2. 2.]]
De igual forma podriamos realizar operaciones algebraicas con vectores y matrices
import numpy as np
b1=np.array([1,2,3])
b2=np.array([1,0,1])
#b1.dot(b2) determina el producto escalar entre los vectores b1 y b2
print(b1.dot(b2))
4
Asi tambien podriamos transponer una matriz mediante a.T.
import numpy as np
a=np.array([[1,2,3],[4,5,6]])
print(a)
print(a.T)
[[1 2 3] [4 5 6]] [[1 4] [2 5] [3 6]]
Incluso podemos resolver sistemas de ecuaciones lineales mediante solve(a,b).
import numpy as np
# El siguiente es un sistema de 2 ecuaciones lineales con 2 variables
#2x+3y=10
#4x+5y=8
a=np.array([[2,3],[4,5]])
b=np.array([10,8])
print(np.linalg.solve(a,b))
[-13. 12.]
Algunas otras funciones para trabajar con algebra lineal son las siguientes:
|Método|Operación |Descripción| |--|--|--| a.dot(b)|Producto escalar|Determina el producto escalar entre los vectores a y b.| |norm(a)|Módulo de un vector|Determina el módulo del vector v.| |a.dot(b)|Producto de 2 matrices|Determina el producto matricial de las matrices a y b.| |a.T|Matriz traspuesta|Determina la matriz traspuesta de la matriz a.| |a.trace()|Traza de una matriz|Determina la suma diagonal principal de la matriz cuadrada a.| |det(a)|Determinante de una matriz|Entrega el determinante de la matriz a.| |inv(a)|Matriz Inversa|Determina la matriz inversa de la matriz cuadrada a.| |eigvals(a)|Autovalores de una matriz|Determina los autovalores de la matriz cuadrada a.| |eig(a)|Autovectores de una matriz|Determina los autovectores de la matriz cuadrada a.| |solve(a,b)|Solución de un sistema de ecuaciones|Determina la solución de un sistema de ecuaciones lineales.|
Ha llegado el momento...🥁 hasta ahora hemos visto la definición de variables de distinto tipo asi como estruturas de datos,entre otros aspectos reelevantes en Python,incluso ya cargamos Numpy...nuestra primera libreria.
Pero ahora toca el turno de utilizar la libreria Matplotlib,la cual es una libreria desarrollada para la creación de gráficos.Cabe destacar que no es la unica libreria para desarrollo de gráficos.
Alguno de los gráficos que se pueden desarrollar con Matplotlib y que veremos son los siguientes:
Uno de los gráficos mas utilizados son los diagramas de dispersión,ya que rapidamente nos permite visualizar como se distribuyen los datos en el espacio.En algunos casos tendremos que utilizar otros gráficos para representar de mejor forma la información,pero es un buen punto de partida. 💡
#Traemos el módulo pyplot de forma abreviada como plt
import matplotlib.pyplot as plt
#Se crea la figura y los ejes
fig,ax=plt.subplots()
#Se definen los puntos tanto del eje x como del y donde diagrama
ax.scatter(x=[1,1.5,2,2.5,3],y=[1,1.5,2,1.5,1])
#Opcionalmente podemos definir el tamaño de la figura
fig.set_size_inches(4,4)
#Finalmente mostramos el grafico
plt.show()
Sin embargo para realizar algunos graficos como los ya mencionados,podemos utilizar funciones desarrolladas especificamente para esa tarea,a continuación se muestran:
Para desarrollar un diagrama de dispersión,que nos permita visualizar los puntos con coordenadas en los eje x e y,debemos utilizar la función scatter(x,y) como en le caso anterior que vimos,pero sin duda que podriamos representar un mayor conjunto de datos.
import matplotlib.pyplot as plt
fig,ax=plt.subplots()
ax.scatter([1,3,0.5,5,0.4,1.9,2.6],[0.9,3,5,2.5,7.6,4.3,7])
#Recordar que la definición del tamaño de la figura es opcional
fig.set_size_inches(4,4)
plt.show()
Con el diagrama de lineas buscamos representar nuevamente un conjunto de puntos que tengan coordenadas en x e y,sin embargo ademas se conectan las distancias entre cada para de puntos sucesivos con la función plot(x,y)
import matplotlib.pyplot as plt
fig,ax=plt.subplots()
ax.plot([1.5,2,3,4],[1,0.75,1.5,0.5])
fig.set_size_inches(4,4)
plt.show()
A diferencia de los gráficos anteriores,en este caso el diagrama de cajas permite visualizar algunos estadisticos relevantes de una muestra.En este caso debemos utilizar la funcion boxplot(x)
import matplotlib.pyplot as plt
fig,ax=plt.subplots()
ax.boxplot([2.3,4.5,1,8,10,4.5,5.6,7.6,3.4,2.4,20])
fig.set_size_inches(4,4)
plt.show()
El gráfico de barras nos permite visualizar generalmente 2 ejes,en donde en el eje y posicionamos las categorias y en el eje x la magnitud contabilizada para cada categoría.
Asi para desarrollar un diagrama de barras en Python usamos la sintaxis barh(x,y)
import matplotlib.pyplot as plt
fig,ax=plt.subplots()
ax.barh([1,2,3],[3,2,1])
fig.set_size_inches(4,4)
plt.show()
Finalmente uno de los graficos mas utilizados en estadistica descriptiva e inferencial junto al graficos de cajas.El histograma nos permite visualizar la distribución de frecuencias una vez que agrupamos los datos en una muestra,cabe destacar que podemos definir la cantidad de columnas que queremos que tenga nuestro diagrama.
En este caso utilizaremos ademas la libreria numpy para utilizar la generación de 1000 números aleatorias mediante una distribución normal con $\bar{X}=10$ y $\sigma=0.8$.
import numpy as np
import matplotlib.pyplot as plt
fig,ax=plt.subplots()
x=np.random.normal(10,0.8,1000)
ax.hist(x,10)
fig.set_size_inches(4,4)
plt.show()
Asi como vimos con la librería Matplotlib,con Plotly también es posible el desarrollo de gráficos,sin embargo es posible el desarrollo de una mayor cantidad de gráficos que con matplotlib,pudiendo desarrollar gráficos de carácter estadístico,financiero,geográfico,científico y en 3 dimensiones.
Junto a lo anterior Plotly,permite el desarrollo de graficos interactivos que pueden ser implementados en jupyter notebook como el presente,guardados en formato HTML o incluso en aplicaciones utilizando Dash,Shiny u otros frameworks
Asi como con matplotlib comenzamos viendo los graficos de dispersion,en este caso tambien podemos desarrollar un primer grafico de este tipo,teniendo la consideración que debemos cargar la libreria Plotly
import plotly.express as px
#Se importa el submodulo .offline para luego usar plotly en el documento HTML
import plotly.offline as pyo
pyo.init_notebook_mode()
fig = px.scatter(x=[0, 1, 2, 3, 4], y=[0, 1, 4, 9, 16])
fig.show()
Si bien visualmente tienen algunas diferencias mínimas los gráficos de dispersión desarrollados con Matplotlib y Plotly,tal vez uno de sus aspectos mas importantes radica es que al tener una sintáxis muy parecida ademas se incluye la posibilidad de interactuar con el gráfico,mediante herramientas como zoom,recortes e incluso la descarga del gráfico.
Algunos otros de los graficos que podemos desarrollar con la libreria Plotly son los siguientes:
Asi como vimos con el gráfico de dispersión tambien podemo desarrollar graficos de lineas en donde podemos visualizar 1 o mas series si fuera necesario,a continuación se muestra la sintaxis para este tipo de gráfico
import plotly.express as px
import pandas as pd
fig= px.line(
x = [1, 2, 3, 4],
y = [1, 2, 3, 4]
)
fig.show()
Cuando realizamos un gráfico de barra,en el eje X se ordenan las categorias que queremos visualizar y en el eje y los valores o cantidades para cada una de estas categorias. Para el desarrollo de gráfico consideremos la siguiente tabla:
| País | Medallas | Cantidad | |||
|---|---|---|---|---|---|
| Corea del Sur | Oro | 25 | |||
| China | Oro | 10 | |||
| Canada | Oro | 9 | |||
| Corea del Sur | Plata | 13 | |||
| China | Plata | 15 | |||
| Canada | Plata | 12 | |||
| Corea del Sur | Bronce | 11 | |||
| China | Bronce | 8 | |||
| Canada | Bronce | 12 | |||